#define PNG_INTERNAL
#define PNG_NO_EXTERN
#include "png.h"

typedef version_1_2_7 Your_png_h_is_not_version_1_2_7;

#ifdef PNG_USE_GLOBAL_ARRAYS
const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;
const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};

PNG_IHDR;
PNG_IDAT;
PNG_IEND;
PNG_PLTE;
PNG_bKGD;
PNG_cHRM;
PNG_gAMA;
PNG_hIST;
PNG_iCCP;
PNG_iTXt;
PNG_oFFs;
PNG_pCAL;
PNG_sCAL;
PNG_pHYs;
PNG_sBIT;
PNG_sPLT;
PNG_sRGB;
PNG_tEXt;
PNG_tIME;
PNG_tRNS;
PNG_zTXt;

const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};

#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};
#endif

const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
const int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

#endif

void PNGAPI png_set_sig_bytes( png_structp png_ptr, int num_bytes ) {
  png_debug( 1, "in png_set_sig_bytes\n" );
  if( num_bytes > 8 ) {
    png_error( png_ptr, "Too many bytes for PNG signature." );
  }
  png_ptr->sig_bytes = ( png_byte )( num_bytes < 0 ? 0 : num_bytes );
}

int PNGAPI png_sig_cmp( png_bytep sig, png_size_t start, png_size_t num_to_check ) {
  png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  if( num_to_check > 8 ) {
    num_to_check = 8;
  } else if( num_to_check < 1 ) {
    return ( 0 );
  }
  if( start > 7 ) {
    return ( 0 );
  }
  if( start + num_to_check > 8 ) {
    num_to_check = 8 - start;
  }
  return ( ( int )( png_memcmp( &sig[start], &png_signature[start], num_to_check ) ) );
}

int PNGAPI png_check_sig( png_bytep sig, int num ) {
  return ( ( int )!png_sig_cmp( sig, ( png_size_t )0, ( png_size_t )num ) );
}

#ifdef PNG_1_0_X
voidpf PNGAPI
#else
voidpf
#endif
png_zalloc( voidpf png_ptr, uInt items, uInt size ) {
  png_voidp ptr;
  png_structp p = ( png_struct* )png_ptr;
  png_uint_32 save_flags = p->flags;
  png_uint_32 num_bytes;
  if( items > PNG_UINT_32_MAX / size ) {
    png_warning( png_ptr, "Potential overflow in png_zalloc()" );
    return ( NULL );
  }
  num_bytes = ( png_uint_32 )items * size;
  p->flags |= PNG_FLAG_MALLOC_NULL_MEM_OK;
  ptr = ( png_voidp )png_malloc( ( png_structp )png_ptr, num_bytes );
  p->flags = save_flags;
  #if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)
  if( ptr == NULL ) {
    return ( ( voidpf )ptr );
  }
  if( num_bytes > ( png_uint_32 )0x8000L ) {
    png_memset( ptr, 0, ( png_size_t )0x8000L );
    png_memset( ( png_bytep )ptr + ( png_size_t )0x8000L, 0,
                ( png_size_t )( num_bytes - ( png_uint_32 )0x8000L ) );
  } else
  { png_memset( ptr, 0, ( png_size_t )num_bytes ); }
  #endif
  return ( ( voidpf )ptr );
}

#ifdef PNG_1_0_X
void PNGAPI
#else
void
#endif
png_zfree( voidpf png_ptr, voidpf ptr ) {
  png_free( ( png_structp )png_ptr, ( png_voidp )ptr );
}

void png_reset_crc( png_structp png_ptr ) {
  png_ptr->crc = crc32( 0, Z_NULL, 0 );
}

void png_calculate_crc( png_structp png_ptr, png_bytep ptr, png_size_t length ) {
  int need_crc = 1;
  if( png_ptr->chunk_name[0] & 0x20 ) {
    if( ( png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK ) ==
        ( PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN ) ) {
      need_crc = 0;
    }
  } else {
    if( png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE ) {
      need_crc = 0;
    }
  }
  if( need_crc ) {
    png_ptr->crc = crc32( png_ptr->crc, ptr, ( uInt )length );
  }
}

png_infop PNGAPI png_create_info_struct( png_structp png_ptr ) {
  png_infop info_ptr;
  png_debug( 1, "in png_create_info_struct\n" );
  if( png_ptr == NULL ) {
    return ( NULL );
  }
  #ifdef PNG_USER_MEM_SUPPORTED
  info_ptr = ( png_infop )png_create_struct_2( PNG_STRUCT_INFO,
             png_ptr->malloc_fn, png_ptr->mem_ptr );
  #else
  info_ptr = ( png_infop )png_create_struct( PNG_STRUCT_INFO );
  #endif
  if( info_ptr != NULL ) {
    png_info_init_3( &info_ptr, png_sizeof( png_info ) );
  }
  return ( info_ptr );
}

void PNGAPI png_destroy_info_struct( png_structp png_ptr, png_infopp info_ptr_ptr ) {
  png_infop info_ptr = NULL;
  png_debug( 1, "in png_destroy_info_struct\n" );
  if( info_ptr_ptr != NULL ) {
    info_ptr = *info_ptr_ptr;
  }
  if( info_ptr != NULL ) {
    png_info_destroy( png_ptr, info_ptr );
    #ifdef PNG_USER_MEM_SUPPORTED
    png_destroy_struct_2( ( png_voidp )info_ptr, png_ptr->free_fn,
                          png_ptr->mem_ptr );
    #else
    png_destroy_struct( ( png_voidp )info_ptr );
    #endif
    *info_ptr_ptr = NULL;
  }
}

#undef png_info_init
void PNGAPI png_info_init( png_infop info_ptr ) {
  png_info_init_3( &info_ptr, 0 );
}

void PNGAPI png_info_init_3( png_infopp ptr_ptr, png_size_t png_info_struct_size ) {
  png_infop info_ptr = *ptr_ptr;
  png_debug( 1, "in png_info_init_3\n" );
  if( png_sizeof( png_info ) > png_info_struct_size ) {
    png_destroy_struct( info_ptr );
    info_ptr = ( png_infop )png_create_struct( PNG_STRUCT_INFO );
    *ptr_ptr = info_ptr;
  }
  png_memset( info_ptr, 0, png_sizeof( png_info ) );
}

#ifdef PNG_FREE_ME_SUPPORTED
void PNGAPI png_data_freer( png_structp png_ptr, png_infop info_ptr,
                int freer, png_uint_32 mask ) {
  png_debug( 1, "in png_data_freer\n" );
  if( png_ptr == NULL || info_ptr == NULL ) {
    return;
  }
  if( freer == PNG_DESTROY_WILL_FREE_DATA ) {
    info_ptr->free_me |= mask;
  } else if( freer == PNG_USER_WILL_FREE_DATA ) {
    info_ptr->free_me &= ~mask;
  } else
    png_warning( png_ptr, "Unknown freer parameter in png_data_freer." );
}
#endif

void PNGAPI png_free_data( png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num ) {
  png_debug( 1, "in png_free_data\n" );
  if( png_ptr == NULL || info_ptr == NULL ) {
    return;
  }
  #if defined(PNG_TEXT_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_TEXT ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_TEXT )
  #endif
  {
    if( num != -1 ) {
      if( info_ptr->text && info_ptr->text[num].key ) {
        png_free( png_ptr, info_ptr->text[num].key );
        info_ptr->text[num].key = NULL;
      }
    } else {
      int i;
      for( i = 0; i < info_ptr->num_text; i++ ) { png_free_data( png_ptr, info_ptr, PNG_FREE_TEXT, i ); }
      png_free( png_ptr, info_ptr->text );
      info_ptr->text = NULL;
      info_ptr->num_text = 0;
    }
  }
  #endif
  #if defined(PNG_tRNS_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_TRNS ) & info_ptr->free_me )
  #else
  if( ( mask & PNG_FREE_TRNS ) && ( png_ptr->flags & PNG_FLAG_FREE_TRNS ) )
  #endif
  {
    png_free( png_ptr, info_ptr->trans );
    info_ptr->valid &= ~PNG_INFO_tRNS;
    #ifndef PNG_FREE_ME_SUPPORTED
    png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
    #endif
    info_ptr->trans = NULL;
  }
  #endif
  #if defined(PNG_sCAL_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_SCAL ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_SCAL )
  #endif
  {
    #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
    png_free( png_ptr, info_ptr->scal_s_width );
    png_free( png_ptr, info_ptr->scal_s_height );
    info_ptr->scal_s_width = NULL;
    info_ptr->scal_s_height = NULL;
    #endif
    info_ptr->valid &= ~PNG_INFO_sCAL;
  }
  #endif
  #if defined(PNG_pCAL_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_PCAL ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_PCAL )
  #endif
  {
    png_free( png_ptr, info_ptr->pcal_purpose );
    png_free( png_ptr, info_ptr->pcal_units );
    info_ptr->pcal_purpose = NULL;
    info_ptr->pcal_units = NULL;
    if( info_ptr->pcal_params != NULL ) {
      int i;
      for( i = 0; i < ( int )info_ptr->pcal_nparams; i++ ) {
        png_free( png_ptr, info_ptr->pcal_params[i] );
        info_ptr->pcal_params[i] = NULL;
      }
      png_free( png_ptr, info_ptr->pcal_params );
      info_ptr->pcal_params = NULL;
    }
    info_ptr->valid &= ~PNG_INFO_pCAL;
  }
  #endif
  #if defined(PNG_iCCP_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_ICCP ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_ICCP )
  #endif
  {
    png_free( png_ptr, info_ptr->iccp_name );
    png_free( png_ptr, info_ptr->iccp_profile );
    info_ptr->iccp_name = NULL;
    info_ptr->iccp_profile = NULL;
    info_ptr->valid &= ~PNG_INFO_iCCP;
  }
  #endif
  #if defined(PNG_sPLT_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_SPLT ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_SPLT )
  #endif
  {
    if( num != -1 ) {
      if( info_ptr->splt_palettes ) {
        png_free( png_ptr, info_ptr->splt_palettes[num].name );
        png_free( png_ptr, info_ptr->splt_palettes[num].entries );
        info_ptr->splt_palettes[num].name = NULL;
        info_ptr->splt_palettes[num].entries = NULL;
      }
    } else {
      if( info_ptr->splt_palettes_num ) {
        int i;
        for( i = 0; i < ( int )info_ptr->splt_palettes_num; i++ ) { png_free_data( png_ptr, info_ptr, PNG_FREE_SPLT, i ); }
        png_free( png_ptr, info_ptr->splt_palettes );
        info_ptr->splt_palettes = NULL;
        info_ptr->splt_palettes_num = 0;
      }
      info_ptr->valid &= ~PNG_INFO_sPLT;
    }
  }
  #endif
  #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_UNKN ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_UNKN )
  #endif
  {
    if( num != -1 ) {
      if( info_ptr->unknown_chunks ) {
        png_free( png_ptr, info_ptr->unknown_chunks[num].data );
        info_ptr->unknown_chunks[num].data = NULL;
      }
    } else {
      int i;
      if( info_ptr->unknown_chunks_num ) {
        for( i = 0; i < ( int )info_ptr->unknown_chunks_num; i++ ) { png_free_data( png_ptr, info_ptr, PNG_FREE_UNKN, i ); }
        png_free( png_ptr, info_ptr->unknown_chunks );
        info_ptr->unknown_chunks = NULL;
        info_ptr->unknown_chunks_num = 0;
      }
    }
  }
  #endif
  #if defined(PNG_hIST_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_HIST )  & info_ptr->free_me )
  #else
  if( ( mask & PNG_FREE_HIST ) && ( png_ptr->flags & PNG_FLAG_FREE_HIST ) )
  #endif
  {
    png_free( png_ptr, info_ptr->hist );
    info_ptr->hist = NULL;
    info_ptr->valid &= ~PNG_INFO_hIST;
    #ifndef PNG_FREE_ME_SUPPORTED
    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
    #endif
  }
  #endif
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_PLTE ) & info_ptr->free_me )
  #else
  if( ( mask & PNG_FREE_PLTE ) && ( png_ptr->flags & PNG_FLAG_FREE_PLTE ) )
  #endif
  {
    png_zfree( png_ptr, info_ptr->palette );
    info_ptr->palette = NULL;
    info_ptr->valid &= ~PNG_INFO_PLTE;
    #ifndef PNG_FREE_ME_SUPPORTED
    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
    #endif
    info_ptr->num_palette = 0;
  }
  #if defined(PNG_INFO_IMAGE_SUPPORTED)
  #ifdef PNG_FREE_ME_SUPPORTED
  if( ( mask & PNG_FREE_ROWS ) & info_ptr->free_me )
  #else
  if( mask & PNG_FREE_ROWS )
  #endif
  {
    if( info_ptr->row_pointers ) {
      int row;
      for( row = 0; row < ( int )info_ptr->height; row++ ) {
        png_free( png_ptr, info_ptr->row_pointers[row] );
        info_ptr->row_pointers[row] = NULL;
      }
      png_free( png_ptr, info_ptr->row_pointers );
      info_ptr->row_pointers = NULL;
    }
    info_ptr->valid &= ~PNG_INFO_IDAT;
  }
  #endif
  #ifdef PNG_FREE_ME_SUPPORTED
  if( num == -1 ) {
    info_ptr->free_me &= ~mask;
  } else { info_ptr->free_me &= ~( mask & ~PNG_FREE_MUL ); }
  #endif
}

void png_info_destroy( png_structp png_ptr, png_infop info_ptr ) {
  png_debug( 1, "in png_info_destroy\n" );
  png_free_data( png_ptr, info_ptr, PNG_FREE_ALL, -1 );
  #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  if( png_ptr->num_chunk_list ) {
    png_free( png_ptr, png_ptr->chunk_list );
    png_ptr->chunk_list = NULL;
    png_ptr->num_chunk_list = 0;
  }
  #endif
  png_info_init_3( &info_ptr, png_sizeof( png_info ) );
}

png_voidp PNGAPI png_get_io_ptr( png_structp png_ptr ) {
  return ( png_ptr->io_ptr );
}

#if !defined(PNG_NO_STDIO)

void PNGAPI png_init_io( png_structp png_ptr, png_FILE_p fp ) {
  png_debug( 1, "in png_init_io\n" );
  png_ptr->io_ptr = ( png_voidp )fp;
}
#endif

#if defined(PNG_TIME_RFC1123_SUPPORTED)

png_charp PNGAPI png_convert_to_rfc1123( png_structp png_ptr, png_timep ptime ) {
  static PNG_CONST char short_months[12][4] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  };
  if( png_ptr->time_buffer == NULL ) {
    png_ptr->time_buffer = ( png_charp )png_malloc( png_ptr, ( png_uint_32 )( 29 *
                           png_sizeof( char ) ) );
  }
  #if defined(_WIN32_WCE)
  {
  wchar_t time_buf[29];
  wsprintf( time_buf, TEXT( "%d %S %d %02d:%02d:%02d +0000" ),
            ptime->day % 32, short_months[( ptime->month - 1 ) % 12],
            ptime->year, ptime->hour % 24, ptime->minute % 60,
            ptime->second % 61 );
  WideCharToMultiByte( CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,
                       NULL, NULL );
}
  #else
  #ifdef USE_FAR_KEYWORD
  {
    char near_time_buf[29];
    sprintf( near_time_buf, "%d %s %d %02d:%02d:%02d +0000",
             ptime->day % 32, short_months[( ptime->month - 1 ) % 12],
             ptime->year, ptime->hour % 24, ptime->minute % 60,
             ptime->second % 61 );
    png_memcpy( png_ptr->time_buffer, near_time_buf,
                29 * png_sizeof( char ) );
  }
  #else
  sprintf( png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
           ptime->day % 32, short_months[( ptime->month - 1 ) % 12],
           ptime->year, ptime->hour % 24, ptime->minute % 60,
           ptime->second % 61 );
  #endif
  #endif /* _WIN32_WCE */
return ( ( png_charp )png_ptr->time_buffer );
}
#endif /* PNG_TIME_RFC1123_SUPPORTED */

png_charp PNGAPI png_get_copyright( png_structp png_ptr ) {
  if( &png_ptr != NULL ) /* silence compiler warning about unused png_ptr */
    return ( ( png_charp ) "\n libpng version 1.2.7 - September 12, 2004\n\
   Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\
   Copyright (c) 1996-1997 Andreas Dilger\n\
   Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n" );
  return ( ( png_charp ) "" );
}

png_charp PNGAPI png_get_libpng_ver( png_structp png_ptr ) {
  /* Version of *.c files used when building libpng */
  if( &png_ptr != NULL ) /* silence compiler warning about unused png_ptr */
  { return ( ( png_charp ) PNG_LIBPNG_VER_STRING ); }
  return ( ( png_charp ) "" );
}

png_charp PNGAPI png_get_header_ver( png_structp png_ptr ) {
  /* Version of *.h files used when building libpng */
  if( &png_ptr != NULL ) /* silence compiler warning about unused png_ptr */
  { return ( ( png_charp ) PNG_LIBPNG_VER_STRING ); }
  return ( ( png_charp ) "" );
}

png_charp PNGAPI png_get_header_version( png_structp png_ptr ) {
  /* Returns longer string containing both version and date */
  if( &png_ptr != NULL ) /* silence compiler warning about unused png_ptr */
  { return ( ( png_charp ) PNG_HEADER_VERSION_STRING ); }
  return ( ( png_charp ) "" );
}

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
int PNGAPI png_handle_as_unknown( png_structp png_ptr, png_bytep chunk_name ) {
  /* check chunk_name and return "keep" value if it's on the list, else 0 */
  int i;
  png_bytep p;
  if( ( png_ptr == NULL && chunk_name == NULL ) || png_ptr->num_chunk_list <= 0 ) {
    return 0;
  }
  p = png_ptr->chunk_list + png_ptr->num_chunk_list * 5 - 5;
  for( i = png_ptr->num_chunk_list; i; i--, p -= 5 )
    if( !png_memcmp( chunk_name, p, 4 ) ) {
      return ( ( int ) * ( p + 4 ) );
    }
  return 0;
}
#endif

/* This function, added to libpng-1.0.6g, is untested. */
int PNGAPI png_reset_zstream( png_structp png_ptr ) {
  return ( inflateReset( &png_ptr->zstream ) );
}

/* This function was added to libpng-1.0.7 */
png_uint_32 PNGAPI png_access_version_number( void ) {
  /* Version of *.c files used when building libpng */
  return( ( png_uint_32 ) PNG_LIBPNG_VER );
}


#if !defined(PNG_1_0_X)
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
void /* PRIVATE */
png_init_mmx_flags( png_structp png_ptr ) {
  png_ptr->mmx_rowbytes_threshold = 0;
  png_ptr->mmx_bitdepth_threshold = 0;
  #  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))
  png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;
  if( png_mmx_support() > 0 ) {
    png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
                          #    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
                          | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
                          #    endif
                          #    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
                          | PNG_ASM_FLAG_MMX_READ_INTERLACE
                          #    endif
                          #    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
                          ;
                          #    else
                          | PNG_ASM_FLAG_MMX_READ_FILTER_SUB
                          | PNG_ASM_FLAG_MMX_READ_FILTER_UP
                          | PNG_ASM_FLAG_MMX_READ_FILTER_AVG
                          | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
    png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;
    png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;
                          #    endif
  } else {
    png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
                             | PNG_MMX_READ_FLAGS
                             | PNG_MMX_WRITE_FLAGS );
  }
  #  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */
  /* clear all MMX flags; no support is compiled in */
  png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );
  #  endif /* ?(PNGVCRD || PNGGCCRD) */
}

#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */

/* this function was added to libpng 1.2.0 */
#if !defined(PNG_USE_PNGGCCRD) && \
!(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))
int PNGAPI png_mmx_support( void ) {
  return -1;
}
#endif
#endif /* PNG_1_0_X */

#ifdef PNG_SIZE_T
/* Added at libpng version 1.2.6 */
PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG( ( size_t size ) );
png_size_t PNGAPI png_convert_size( size_t size ) {
  if( size > ( png_size_t ) - 1 ) {
    PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */
  }
  return ( ( png_size_t )size );
}
#endif /* PNG_SIZE_T */
